home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / MCASM.RAR / MC_ASM.EXE / WROX_ASM / CH12 / EFFECTS / SCREFF.CPP < prev    next >
C/C++ Source or Header  |  1994-11-14  |  10KB  |  470 lines
  1. #include <mem.h>
  2. #include <dos.h>
  3. #include <stdlib.h>
  4.  
  5. #include "common.h"
  6. #include "graph.h"
  7. #include "screff.h"
  8.  
  9. pointtype arrp[32*20*7];
  10. unsigned char arrhits[32*20*7];
  11.  
  12. void showbuffer(int x1,int y1,int x2,int y2,void *p1,void *v)
  13. {
  14. int i;
  15. for(i=y1;i<=y2;i++)
  16. memcpy(&MixBuffer(v)[i][x1],&MixBuffer(p1)[i][x1],x2-x1+1);
  17. }
  18.  
  19. void BadFAX(int x1,int y1,int x2,int y2,
  20.         int delta,int uord,void *p1,void *v)
  21. {
  22. int sx,i,j;
  23. sx = x2-x1+1;
  24. if (uord == 1)
  25. {
  26.     for(i=y2;i>=y1+delta;i--)
  27.     {
  28.         memcpy(&MixBuffer(v)[i-delta][x1],
  29.             &MixBuffer(p1)[i][x1],sx);
  30.         for(j=0;j<=delta-1;j++)
  31.             memcpy(&MixBuffer(v)[i-delta+j+1][x1],
  32.             &MixBuffer(v)[i-delta+j][x1],sx);
  33.         delay(5);
  34.     }
  35.     for(i=y1+delta-1;i>=y1;i--)
  36.     {
  37.         memcpy(&MixBuffer(v)[y1][x1],
  38.             &MixBuffer(p1)[i][x1],sx);
  39.         for(j=0;j<=i-y1;j++)
  40.         memcpy(&MixBuffer(v)[y1+j][x1],
  41.             &MixBuffer(v)[y1][x1],sx);
  42.         delay(5);
  43.     }
  44. }
  45. else
  46. {
  47.     for(i=y1;i<=y2-delta;i++)
  48.     {
  49.         memcpy(&MixBuffer(v)[i+delta][x1],
  50.             &MixBuffer(p1)[i][x1],sx);
  51.         for(j=0;j<=delta-1;j++)
  52.             memcpy(&MixBuffer(v)[i+delta-j-1][x1],
  53.             &MixBuffer(v)[i+delta-j][x1],sx);
  54.         delay(5);
  55.     }
  56.     for(i=y2-delta+1;i<=y2;i++)
  57.     {
  58.         memcpy(&MixBuffer(v)[y2][x1],
  59.             &MixBuffer(p1)[i][x1],sx);
  60.         for(j=0;j<=y2-i;j++)
  61.             memcpy(&MixBuffer(v)[y2-j][x1],
  62.                 &MixBuffer(v)[y2][x1],sx);
  63.         delay(5);
  64.     }
  65. }
  66. }
  67.  
  68. void ShowFromCorner(int x1,int y1,int x2,int y2,
  69.             int s,int coner,void *p1,void *v)
  70. {
  71. int i,j,dx,dy;
  72. dx = (x2-x1+1)/s;
  73. dy = (y2-y1+1)/s;
  74. switch (coner) {
  75. case     0 : //expand form upper left coner
  76.     for(i=1;i<=s;i++)
  77.     {
  78.         for(j=0;j<=i*dy+dy;j++)
  79.             memcpy(&MixBuffer(v)[y1+j][x1],
  80.                  &MixBuffer(p1)[y1+j][x1],i*dx);
  81.         delay(10);
  82.     } break;
  83. case    1 : //expand form upper right coner
  84.     for(i=1;i<=s;i++)
  85.     {
  86.         for(j=0;j<=i*dy+dy;j++)
  87.             memcpy(&MixBuffer(v)[y1+j][x2-i*dx+1],
  88.             &MixBuffer(p1)[y1+j][x2-i*dx+1],i*dx);
  89.         delay(10);
  90.     } break;
  91. case    2 : //expand form bottom right coner
  92.     for(i=1;i<=s;i++)
  93.     {
  94.         for(j=0;j<=i*dy+dy;j++)
  95.             memcpy(&MixBuffer(v)[y2-j][x2-i*dx+1],
  96.             &MixBuffer(p1)[y2-j][x2-i*dx+1],i*dx);
  97.         delay(10);
  98.     } break;
  99. case    3 : //expand form bottom left coner
  100.     for(i=1;i<=s;i++)
  101.     {
  102.         for(j=0;j<=i*dy+dy;j++)
  103.             memcpy(&MixBuffer(v)[y2-j][x1],
  104.             &MixBuffer(p1)[y2-j][x1],i*dx);
  105.         delay(10);
  106.     } break;
  107. }
  108. showbuffer(x1,y1,x2,y2,p1,v);
  109. }
  110.  
  111. void RandomFillArea(int x1,int y1,int x2,int y2,
  112.             int dx,int dy,void *p1,void *v)
  113. {
  114. int counter,i,j,sx,sy;
  115. counter = 0;
  116. sx=(x2-x1)/dx + 1;
  117. sy=(y2-y1)/dy + 1;
  118. for(j=1;j<=sy*sx;j++) arrhits[j] = 0;
  119. for(i=0;i<=sy-1;i++)
  120.     for(j=1;j<=sx;j++)
  121.     {
  122.         arrp[i*sx+j].x=x1+j*dx-dx;
  123.         arrp[i*sx+j].y=y1+(i+1)*dy-dy;
  124.     }
  125. do
  126. {
  127. do
  128. {
  129. j = random(sy*sx);
  130. if (j == 0) continue;
  131. if (arrhits[j] == 0) {arrhits[j] = 1; break;} else continue;
  132. } while (0 > -1);
  133. counter++;
  134.  
  135. if (((x2 - arrp[j].x) < dx) && ((y2 - arrp[j].y) < dy))
  136.     for(i=0;i<=y2 - arrp[j].y;i++)
  137.         memcpy(&MixBuffer(v)[arrp[j].y+i][arrp[j].x],
  138.         &MixBuffer(p1)[arrp[j].y+i][arrp[j].x],
  139.                 x2 - arrp[j].x+1);
  140. else
  141. if ((x2 - arrp[j].x) < dx)
  142.     for(i=0;i<=dy-1;i++)
  143.         memcpy(&MixBuffer(v)[arrp[j].y+i][arrp[j].x],
  144.               &MixBuffer(p1)[arrp[j].y+i][arrp[j].x],
  145.             x2 - arrp[j].x+1);
  146. else
  147. if ((y2 - arrp[j].y) < dy)
  148.     for(i=0;i<=y2 - arrp[j].y;i++)
  149.         memcpy(&MixBuffer(v)[arrp[j].y+i][arrp[j].x],
  150.         &MixBuffer(p1)[arrp[j].y+i][arrp[j].x],dx);
  151. else
  152. for(i=0;i<=dy-1;i++)
  153.     memcpy(&MixBuffer(v)[arrp[j].y+i][arrp[j].x],
  154.         &MixBuffer(p1)[arrp[j].y+i][arrp[j].x],dx);
  155. if (counter > sx*sy-5)
  156. {
  157. for(j=1;j<=sy*sx;j++)
  158. if (arrhits[j] == 0)
  159. if (((x2 - arrp[j].x) < dx) && ((y2 - arrp[j].y) < dy))
  160.     for(i=0;i<=y2 - arrp[j].y;i++)
  161.         memcpy(&MixBuffer(v)[arrp[j].y+i][arrp[j].x],
  162.         &MixBuffer(p1)[arrp[j].y+i][arrp[j].x],
  163.         x2 - arrp[j].x+1);
  164. else
  165. if ((x2 - arrp[j].x) < dx)
  166.     for(i=0;i<=dy-1;i++)
  167.         memcpy(&MixBuffer(v)[arrp[j].y+i][arrp[j].x],
  168.             &MixBuffer(p1)[arrp[j].y+i][arrp[j].x],
  169.             x2 - arrp[j].x+1);
  170. else
  171. if ((y2 - arrp[j].y) < dy)
  172.     for(i=0;i<=y2 - arrp[j].y;i++)
  173.         memcpy(&MixBuffer(v)[arrp[j].y+i][arrp[j].x],
  174.             &MixBuffer(p1)[arrp[j].y+i][arrp[j].x],dx);
  175. else
  176. for(i=0;i<=dy-1;i++)
  177.     memcpy(&MixBuffer(v)[arrp[j].y+i][arrp[j].x],
  178.         &MixBuffer(p1)[arrp[j].y+i][arrp[j].x],dx);
  179. break;
  180. }
  181. delay(1);
  182. } while (0 > -1);
  183. }
  184.  
  185. void Explode(int x1,int y1,int x2,int y2,void *p1,void *v)
  186. {
  187. int cx,cy,i,j,k;
  188. cx = (x2 - x1 + 1)/2;
  189. cy = (y2 - y1 + 1)/2;
  190. i=j=1;
  191. do
  192. {
  193.     if  (i < cx)
  194.     {
  195.         if (j == cy)
  196.         {
  197.             showbuffer(x1,y1,x2,y2,p1,v);
  198.             i=cx;
  199.         }
  200.         else
  201.         {
  202.             for(k=y1;k<=y2;k++)
  203.             memcpy(&MixBuffer(v)[k][cx-i],
  204.                 &MixBuffer(p1)[k][cx-i],i*2);
  205.             i++;
  206.         }
  207.     }
  208.     if (j < cy)
  209.     {
  210.         if (i == cx)
  211.         {
  212.             showbuffer(x1,y1,x2,y2,p1,v);
  213.             j = cy;
  214.         }
  215.     else
  216.         {
  217.             for(k=y1;k<=2*j+y1;k++)
  218.             memcpy(&MixBuffer(v)[cy-j+k][x1],
  219.             &MixBuffer(p1)[cy-j+k][x1],x2-x1+1);
  220.             j++;
  221.         }
  222.     }
  223. } while (!((i == cx) && (j == cy)));
  224. }
  225.  
  226. void Slide(int x1,int y1,int x2,int y2,
  227.         int step,int ulrd,void *p1,void *v)
  228. {
  229. int dx,i,j;
  230. dx = x2 - x1 + 1;
  231. switch (ulrd) {
  232. case    0 : //up to down
  233.     {
  234.     for(i=0;i<=(y2-y1+1)/step-1;i++)
  235.         for(j=0;j<=i*step;j++)
  236.             memcpy(&MixBuffer(v)[j+y1][x1],
  237.             &MixBuffer(p1)[y2-i*step+j][x1],dx);
  238.     for(j=y1;j<=y2;j++)
  239.         memcpy(&MixBuffer(v)[j][x1],
  240.         &MixBuffer(p1)[j][x1],dx);
  241.     } break;
  242. case    1 : //down to up
  243.     {
  244.     for(i=y1;i<=y2/step;i++)
  245.         for(j=y1;j<=i*step + y1;j++)
  246.             memcpy(&MixBuffer(v)[y2-i*step+j][x1],
  247.             &MixBuffer(p1)[j][x1],x2-x1+1);
  248.     for(j=y2;j>=y1;j--)
  249.         memcpy(&MixBuffer(v)[j][x1],
  250.             &MixBuffer(p1)[j][x1],x2-x1+1);
  251.     } break;
  252. case    2 :  //right to left
  253.     {
  254.     for(i=1;i<=dx/step;i++)
  255.         for(j=y1;j<=y2;j++)
  256.             memcpy(&MixBuffer(v)[j][x1+dx-i*step],
  257.                 &MixBuffer(p1)[j][x1],i*step);
  258.     showbuffer(x1,y1,x2,y2,p1,v);
  259.     } break;
  260. case    3 : //left to right
  261.     {
  262.     for(i=1;i<=dx/step;i++)
  263.         for(j=y1;j<=y2;j++)
  264.            memcpy(&MixBuffer(v)[j][x1],
  265.            &MixBuffer(p1)[j][x1+dx-i*step],i*step);
  266.     showbuffer(x1,y1,x2,y2,p1,v);
  267.     }
  268. }
  269. }
  270.  
  271. //if direct = 0 then y2-y1 must be even
  272. //and if direct = 1 then x2-x1 must be even
  273. void ShowFromCenter(int x1,int y1,int x2,int y2,
  274.             int direct,void *p1,void *v)
  275. {
  276. int dx,dy,dy2,i,j;
  277. if (direct == 0)
  278. {
  279.     dx=x2-x1+1;
  280.     dy=y2-y1+1;
  281.     dy2=dy/2 + y1;
  282.     for(i=0;i<=dy2 - y1 - 1;i++)
  283.     {
  284.         memcpy(&MixBuffer(v)[dy2-i][x1],
  285.             &MixBuffer(p1)[dy2-i][x1],dx);
  286.         memcpy(&MixBuffer(v)[dy2+i][x1],
  287.             &MixBuffer(p1)[dy2+i][x1],dx);
  288.         delay(4);
  289.     }
  290. }
  291. else
  292. {
  293.     dx = (x2-x1+1)/2 + x1;
  294.     for(i=0;i<=dx - x1 - 1;i++)
  295.     {
  296.         for(j=y1;j<=y2;j++)
  297.             memcpy(&MixBuffer(v)[j][dx-i],
  298.             &MixBuffer(p1)[j][dx-i],i*2+1);
  299.         delay(1);
  300.     }
  301. }
  302. showbuffer(x1,y1,x2,y2,p1,v);
  303. }
  304.  
  305. void ShowToCenter(int x1,int y1,int x2,int y2,
  306.             int direct,void *p1,void *v)
  307. {
  308. int dx,dy,i,j;
  309. dx=x2-x1+1;
  310. dy=(y2-y1+1)/2;
  311. if (direct == 0)
  312.     for(i=0;i<=dy;i++)
  313.     {
  314.         memcpy(&MixBuffer(v)[y1+i][x1],
  315.             &MixBuffer(p1)[y1+i][x1],dx);
  316.         memcpy(&MixBuffer(v)[y2-i][x1],
  317.             &MixBuffer(p1)[y2-i][x1],dx);
  318.         delay(5);
  319.     }
  320. else
  321. {
  322.     dx = (x2-x1+1)/2;
  323.     for(i=0;i<=dx;i++)
  324.         for(j=y1;j<=y2;j++)
  325.         {
  326.             memcpy(&MixBuffer(v)[j][x1],
  327.                 &MixBuffer(p1)[j][x1],i+1);
  328.             memcpy(&MixBuffer(v)[j][x2-i],
  329.                 &MixBuffer(p1)[j][x2-i],i+1);
  330.         }
  331. }
  332. }
  333.  
  334. void Jalousie(int x1,int y1,int x2,int y2,int step,
  335.             int direct,void *p1,void *v)
  336. {
  337. int dx,dy2,dy,i,j;
  338. dx = (x2 - x1 + 1);
  339. dy = (y2 - y1 + 1);
  340. dy2 = dy/step;
  341. if (direct == 0)
  342. {
  343.     for(i=y1;i<=step - 1 + y1;i++)
  344.     {
  345.         for(j=0;j<=dy2 - 1;j++)
  346.             memcpy(&MixBuffer(v)[i+j*step][x1],
  347.             &MixBuffer(p1)[i+j*step][x1],dx);
  348.         if (((dy % step) != 0) && ((i+j*step) <= y2))
  349.             memcpy(&MixBuffer(v)[i+j*step][x1],
  350.             &MixBuffer(p1)[i+j*step][x1],dx);
  351.         delay(10);
  352.     }
  353. }
  354. else
  355. {
  356.     for(i=step-1+y1;i>=y1;i--)
  357.     {
  358.         for(j=dy2-1;j>=0;j--)
  359.             memcpy(&MixBuffer(v)[i+j*step][x1],
  360.             &MixBuffer(p1)[i+j*step][x1],dx);
  361.         if (((dy % step) != 0) && ((i+(j+1)*step) <= y2))
  362.             memcpy(&MixBuffer(v)[i+(j+1)*step][x1],
  363.             &MixBuffer(p1)[i+(j+1)*step][x1],dx);
  364.         delay(10);
  365.     }
  366. }
  367. }
  368.  
  369. void Develope(int x1,int y1,int x2,int y2,
  370.             int divisor,void *p1,void *v)
  371. {
  372. long l,dx,dy,i,j;
  373. dx = x2 - x1 + 1;
  374. dy = y2 - y1 + 1;
  375. l = 0;
  376. do
  377. {
  378.     i=((l/dx) % dy) + y1;
  379.     j=(l % dx) + x1;
  380.     *&MixBuffer(v)[i][j] = *&MixBuffer(p1)[i][j];
  381.     l+=divisor;
  382. } while (!((l/divisor) > (dx*dy)));
  383. }
  384.  
  385. void Gone_with_the_wind(int x1,int y1,int x2,int y2,
  386.                 void *p1,void *p2,void *v)
  387. {
  388. int count,l,k,i,j;
  389. int arrx[200];
  390. arrx[y1] = random(20);
  391. for(i=y1+1;i<=y2;i++)
  392. {
  393.     arrx[i] = arrx[i-1] + random(4)-2;
  394.     if (arrx[i] < 0) arrx[i] = 0;
  395. }
  396. for(i=y1;i<=y2;i++)
  397. {
  398.     memcpy(&MixBuffer(v)[i][x1+arrx[i]],
  399.         &MixBuffer(p1)[i][x1],(x2-x1+1)-arrx[i]);
  400.     memcpy(&MixBuffer(v)[i][x1],
  401.         &MixBuffer(p2)[i][x1],arrx[i]);
  402. }
  403. do
  404. {
  405.     k = 0;
  406.     for(i=y1;i<=y2;i++)
  407.     {
  408.         l = (int(random(32001)) - int(16000))/8000;
  409.         k+=l;
  410.         arrx[i]+=k+5;
  411.         if (arrx[i] < 0) arrx[i] = 0;
  412.     }
  413.     for(i=y1+1;i<=y2-1;i++)
  414.     {
  415.         arrx[i] = (arrx[i-1] +2*arrx[i]+ arrx[i+1])/4;
  416.         if (arrx[i] < 0) arrx[i] = 0;
  417.     }
  418.     count = 0;
  419.     for(i=y1;i<=y2;i++)
  420.     {
  421.         k = (x2-x1+1) - arrx[i];
  422.         if (k < 0) k = 0;
  423.         l = arrx[i];
  424.         if (l > (x2-x1)) {l = (x2-x1); count++;}
  425.         memcpy(&MixBuffer(v)[i][x1+l],
  426.             &MixBuffer(p1)[i][x1],k);
  427.         memcpy(&MixBuffer(v)[i][x1],
  428.             &MixBuffer(p2)[i][x1],l+1);
  429.     }
  430. } while (!(count >= (y2-y1-1)));
  431. }
  432.  
  433. void CenterExplode(int x1,int y1,int x2,int y2,int step,void *p1,void *p2,void *v)
  434. {
  435. int dx,dy,i,j;
  436. dx = (x2-x1+1);
  437. dy = (y2-y1+1)/2;
  438. if (p2 == NULL)
  439. {
  440.     for(i=0;i<=dy/step;i++)
  441.         for(j=0;j<=i*step;j++)
  442.         {
  443.             memcpy(&MixBuffer(v)[y1+j+dy-1][x1],
  444.                 &MixBuffer(p1)[y2-i*step+j-1][x1],dx);
  445.             memcpy(&MixBuffer(v)[y1+dy-j][x1],
  446.                 &MixBuffer(p1)[y1+i*step-j][x1],dx);
  447.         }
  448. p2 = p1;
  449. }
  450. else
  451.     for(i=0;i<=dy/step;i++)
  452.     {
  453.         for(j=0;j<=dy-i*step-1;j++)
  454.         {
  455.             memcpy(&MixBuffer(v)[y1+j][x1],
  456.                 &MixBuffer(p1)[y1+i*step+j][x1],dx);
  457.             memcpy(&MixBuffer(v)[y1+dy+i*step+j][x1],
  458.                 &MixBuffer(p1)[y1+dy+j][x1],dx);
  459.         }
  460.         delay(10);
  461.         for(j=0;j<=i*step;j++)
  462.         {
  463.             memcpy(&MixBuffer(v)[y1+j+dy-1][x1],
  464.                 &MixBuffer(p2)[y2-i*step+j][x1],dx);
  465.             memcpy(&MixBuffer(v)[y1+dy-j][x1],
  466.                 &MixBuffer(p2)[y1+i*step-j][x1],dx);
  467.         }
  468.     }
  469. showbuffer(x1,y1,x2,y2,p2,v);
  470. }